package cn.tedu.cqhotel.service.impl;

import cn.tedu.cqhotel.ex.ServiceCode;
import cn.tedu.cqhotel.ex.ServiceException;
import cn.tedu.cqhotel.mapper.StaffManageMapper;
import cn.tedu.cqhotel.pojo.dto.StaffManageAddNewDTO;
import cn.tedu.cqhotel.pojo.dto.StaffManageUpdateDTO;
import cn.tedu.cqhotel.pojo.entity.StaffManage;
import cn.tedu.cqhotel.pojo.vo.StaffManageListItemVO;
import cn.tedu.cqhotel.pojo.vo.StaffManageStandardVO;
import cn.tedu.cqhotel.service.IStaffManageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 处理品牌业务的实现类
 *
 * @author java@tedu.cn
 * @version 0.0.1
 */
@Slf4j
@Service
public class StaffManageServiceImpl implements IStaffManageService{

    @Autowired
    private StaffManageMapper staffManageMapper;


    public StaffManageServiceImpl() {
        log.info("创建业务对象：StaffManageServiceImpl");
    }

    @Override
    public void addNew(StaffManageAddNewDTO staffManageAddNewDTO) {
        log.debug("开始处理【添加员工管理】的业务，参数：{}", staffManageAddNewDTO);

        // 声明父级员工管理对象
        StaffManageStandardVO parentStaffManage = null;
        // 声明局部变量level，默认值为1
        Integer level = 1;
        // 取出参数中的parentId
        Long parentId = staffManageAddNewDTO.getParentId();
        // 判断parentId是否不为0
        if (parentId != 0) {
            log.trace("当前选择了父级员工管理……");
            // 是：调用Mapper对象的【根据id查询详情】，使用parentId作为参数，执行查询
            parentStaffManage = staffManageMapper.getStandardById(parentId);
            log.trace("从数据库中查询父级员工管理为：{}", parentStaffManage);
            // 判断查询结果是否不为null
            if (parentStaffManage != null) {
                // -- 是：局部变量level=父级level+1
                level += parentStaffManage.getLevel();
                log.trace("计算得到当前尝试添加的员工管理的级别：{}", level);
            } else {
                // -- 否：父级员工管理不存在，抛出异常（NOT_FOUND）
                String message = "添加员工管理失败，选定的父级员工管理不存在！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
            }
        }

        // 创建品牌对象，用于插入到数据表
        StaffManage staffManage = new StaffManage();
        BeanUtils.copyProperties(staffManageAddNewDTO, staffManage);
        staffManage.setLevel(level);
        staffManage.setIsParent(0);

        // 插入数据
        log.debug("即将向数据库中插入数据：{}", staffManage);
        int rows = staffManageMapper.insert(staffManage);
        if (rows != 1) {
            String message = "添加员工管理失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_INSERT, message);
        }

        // 判断parentId是否不为0
        if (parentId != 0) {
            // 是：判断父级员工管理的isParent是否为0
            if (parentStaffManage.getIsParent() == 0) {
                log.trace("准备更新父级员工管理的isParent值……");
                // 是：创建新的Category对象，封装：parentId，isParent(1)
                StaffManage updateParentStaffManage = new StaffManage();
                updateParentStaffManage.setId(parentId);
                updateParentStaffManage.setIsParent(1);
                // 调用Mapper对象的【更新】方法，执行修改数据，并获取返回值
                int updateRows = staffManageMapper.updateById(updateParentStaffManage);
                // 判断返回值是否不为1
                if (updateRows != 1) {
                    // 是：抛出异常（ERR_UPDATE）
                    String message = "添加员工管理失败，服务器忙，请稍后再尝试！";
                    log.warn(message);
                    throw new ServiceException(ServiceCode.ERR_UPDATE, message);
                }
                log.trace("更新父级员工管理的数据完成");
            }
        }
    }

    @Override
    public void deleteById(Long id) {
        log.debug("开始处理【删除员工】的业务，参数：{}", id);
        // 调用Mapper对象的getDetailsById()方法执行查询
        StaffManageStandardVO queryResult = staffManageMapper.getStandardById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            // 是：此id对应的数据不存在，则抛出异常(ERR_NOT_FOUND)
            String message = "删除员工管理信息失败，尝试删除的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 检查当前尝试删除的类别是否存在子级类别：判断以上查询结果的isParent是否为1
        if (queryResult.getIsParent() == 1) {
            // 是：当前尝试删除的类别“是父级类别”（包含子级），抛出异常（ERR_CONFLICT）
            String message = "删除员工管理失败，尝试删除的类别仍包含子级类别！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        // 调用Mapper对象的deleteById()执行删除，并获取返回值
        int rows = staffManageMapper.deleteById(id);
        // 判断以上返回值是否不为1
        if (rows != 1) {
            // 是：抛出异常(ERR_DELETE)
            String message = "删除员工管理信息失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_DELETE, message);
        }

        // ====== 如果这是父级员工管理中的最后一个子级，则将父级的isParent改为0 =====
        // 从当前尝试删除的员工管理对象中取出parentId
        Long parentId = queryResult.getParentId();
        // 判断当前员工管理是否不为1级员工管理，即parentId不为0
        if (parentId != 0) {
            // 调用Mapper对象的countByParentId(parentId)进行统计
            int count = staffManageMapper.countByParentId(parentId);
            // 判断统计结果是否为0
            if (count == 0) {
                // 创建新的Category对象，用于更新父级，此Category对象中需要封装：id（parentId），isParent（0）
                StaffManage parentStaffManage = new StaffManage();
                parentStaffManage.setId(parentId);
                parentStaffManage.setIsParent(0);
                // 调用Mapper对象的【更新】功能，执行修改数据，并获取返回值
                rows = staffManageMapper.updateById(parentStaffManage);
                // 判断返回值是否不为1
                if (rows != 1) {
                    // 是：抛出异常（ERR_UPDATE）
                    String message = "删除员工管理失败，服务器忙，请稍后再尝试！";
                    log.warn(message);
                    throw new ServiceException(ServiceCode.ERR_UPDATE, message);
                }
            }
        }
    }

    @Override
    public void updateById(Long id, StaffManageUpdateDTO staffManageUpdateDTO) {
        log.debug("开始处理【修改员工管理信息】的业务，参数：{}", id);
        // 调用Mapper对象的getDetailsById()方法执行查询
        StaffManageStandardVO queryResult = staffManageMapper.getStandardById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            // 是：此id对应的数据不存在，则抛出异常(ERR_NOT_FOUND)
            String message = "修改员工管理信息失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        StaffManage staffManage = new StaffManage();
        BeanUtils.copyProperties(staffManageUpdateDTO, staffManage);
        staffManage.setId(id);

        // 修改数据
        log.debug("即将修改数据：{}", staffManage);
        int rows = staffManageMapper.updateById(staffManage);
        if (rows != 1) {
            String message = "修改员工管理信息失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public void setEnable(Long id) {
        log.debug("开始处理【启用员工管理】的业务，参数：{}", id);
        // 调用Mapper对象的getDetailsById()方法执行查询
        StaffManageStandardVO queryResult = staffManageMapper.getStandardById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            // 是：此id对应的数据不存在，则抛出异常(ERR_NOT_FOUND)
            String message = "启用员工管理失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 判断查询结果中的isEnable是否为1
        if (queryResult.getIsEnable() == 1) {
            // 是：此id对应的品牌已经是启用状态，则抛出异常(ERR_CONFLICT)
            String message = "启用员工管理失败，当前员工管理已经处于启用状态！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        // 创建StaffManage对象（作为修改数据的方法的参数）
        StaffManage staffManage = new StaffManage();
        // 向StaffManage对象中封装id（参数id）与isEnable（固定为1）属性的值
        staffManage.setId(id);
        staffManage.setIsEnable(1);
        // 调用Mapper对象的updateById()修改品牌数据，并获取返回值
        int rows = staffManageMapper.updateById(staffManage);
        // 判断以上返回值是否不为1
        if (rows != 1) {
            // 是：抛出异常(ERR_UPDATE)
            String message = "启用员工管理失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public void setDisable(Long id) {
        log.debug("开始处理【禁用员工管理】的业务，参数：{}", id);
        // 调用Mapper对象的getDetailsById()方法执行查询
        StaffManageStandardVO queryResult = staffManageMapper.getStandardById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            // 是：此id对应的数据不存在，则抛出异常(ERR_NOT_FOUND)
            String message = "禁用员工管理失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 判断查询结果中的enable是否为0
        if (queryResult.getIsEnable() == 0) {
            // 是：此id对应的品牌已经是禁用状态，则抛出异常(ERR_CONFLICT)
            String message = "禁用员工管理失败，当前员工管理已经处于禁用状态！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        // 创建StaffManage对象（作为修改数据的方法的参数）
        StaffManage staffManage = new StaffManage();
        // 向StaffManage对象中封装id（参数id）与enable（固定为0）属性的值
        staffManage.setId(id);
        staffManage.setIsEnable(0);
        // 调用Mapper对象的updateById()修改品牌数据，并获取返回值
        int rows = staffManageMapper.updateById(staffManage);
        // 判断以上返回值是否不为1
        if (rows != 1) {
            // 是：抛出异常(ERR_UPDATE)
            String message = "禁用员工管理失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public StaffManageStandardVO getStandardById(Long id) {
        log.debug("开始处理【根据id查询员工管理信息】的业务");
        StaffManageStandardVO staffManage = staffManageMapper.getStandardById(id);
        if (staffManage == null) {
            // 是：此id对应的数据不存在，则抛出异常(ERR_NOT_FOUND)
            String message = "获取员工管理信息失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        return staffManage;
    }

    @Override
    public List<StaffManageListItemVO> listByName(String name) {
        log.debug("开始处理【根据name查询员工信息】的业务");
        return staffManageMapper.listByName(name);
    }

    @Override
    public List<StaffManageListItemVO> listByParentId(Long parentId) {
        log.debug("开始处理【根据parentId查询员工信息】的业务");
        return staffManageMapper.listByParentId(parentId);
    }

    @Override
    public List<StaffManageListItemVO> list() {
        log.debug("开始处理【查询员工管理信息列表】的业务");
        return staffManageMapper.list();
    }
}
